(function() {
    function require(path, parent, orig) {
        var resolved = require.resolve(path);
        if (null == resolved) {
            orig = orig || path;
            parent = parent || "root";
            var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
            err.path = orig;
            err.parent = parent;
            err.require = true;
            throw err
        }
        var module = require.modules[resolved];
        if (!module._resolving && !module.exports) {
            var mod = {};
            mod.exports = {};
            mod.client = mod.component = true;
            module._resolving = true;
            module.call(this, mod.exports, require.relative(resolved), mod);
            delete module._resolving;
            module.exports = mod.exports
        }
        return module.exports
    }
    require.modules = {};
    require.aliases = {};
    require.resolve = function(path) {
        if (path.charAt(0) === "/") path = path.slice(1);
        var paths = [path, path + ".js", path + ".json", path + "/index.js", path + "/index.json"];
        for (var i = 0; i < paths.length; i++) {
            var path = paths[i];
            if (require.modules.hasOwnProperty(path)) return path;
            if (require.aliases.hasOwnProperty(path)) return require.aliases[path]
        }
    };
    require.normalize = function(curr, path) {
        var segs = [];
        if ("." != path.charAt(0)) return path;
        curr = curr.split("/");
        path = path.split("/");
        for (var i = 0; i < path.length; ++i) {
            if (".." == path[i]) {
                curr.pop()
            } else if ("." != path[i] && "" != path[i]) {
                segs.push(path[i])
            }
        }
        return curr.concat(segs).join("/")
    };
    require.register = function(path, definition) {
        require.modules[path] = definition
    };
    require.alias = function(from, to) {
        if (!require.modules.hasOwnProperty(from)) {
            throw new Error('Failed to alias "' + from + '", it does not exist')
        }
        require.aliases[to] = from
    };
    require.relative = function(parent) {
        var p = require.normalize(parent, "..");

        function lastIndexOf(arr, obj) {
            var i = arr.length;
            while (i--) {
                if (arr[i] === obj) return i
            }
            return -1
        }
        function localRequire(path) {
            var resolved = localRequire.resolve(path);
            return require(resolved, parent, path)
        }
        localRequire.resolve = function(path) {
            var c = path.charAt(0);
            if ("/" == c) return path.slice(1);
            if ("." == c) return require.normalize(p, path);
            var segs = parent.split("/");
            var i = lastIndexOf(segs, "deps") + 1;
            if (!i) i = 0;
            path = segs.slice(0, i + 1).join("/") + "/deps/" + path;
            return path
        };
        localRequire.exists = function(path) {
            return require.modules.hasOwnProperty(localRequire.resolve(path))
        };
        return localRequire
    };
    require.register("abpetkov-transitionize/transitionize.js", function(exports, require, module) {
        module.exports = Transitionize;

        function Transitionize(element, props) {
            if (!(this instanceof Transitionize)) return new Transitionize(element, props);
            this.element = element;
            this.props = props || {};
            this.init()
        }
        Transitionize.prototype.isSafari = function() {
            return /Safari/.test(navigator.userAgent) && /Apple Computer/.test(navigator.vendor)
        };
        Transitionize.prototype.init = function() {
            var transitions = [];
            for (var key in this.props) {
                transitions.push(key + " " + this.props[key])
            }
            this.element.style.transition = transitions.join(", ");
            if (this.isSafari()) this.element.style.webkitTransition = transitions.join(", ")
        }
    });
    require.register("ftlabs-fastclick/lib/fastclick.js", function(exports, require, module) {
        function FastClick(layer) {
            "use strict";
            var oldOnClick, self = this;
            this.trackingClick = false;
            this.trackingClickStart = 0;
            this.targetElement = null;
            this.touchStartX = 0;
            this.touchStartY = 0;
            this.lastTouchIdentifier = 0;
            this.touchBoundary = 10;
            this.layer = layer;
            if (!layer || !layer.nodeType) {
                throw new TypeError("Layer must be a document node")
            }
            this.onClick = function() {
                return FastClick.prototype.onClick.apply(self, arguments)
            };
            this.onMouse = function() {
                return FastClick.prototype.onMouse.apply(self, arguments)
            };
            this.onTouchStart = function() {
                return FastClick.prototype.onTouchStart.apply(self, arguments)
            };
            this.onTouchMove = function() {
                return FastClick.prototype.onTouchMove.apply(self, arguments)
            };
            this.onTouchEnd = function() {
                return FastClick.prototype.onTouchEnd.apply(self, arguments)
            };
            this.onTouchCancel = function() {
                return FastClick.prototype.onTouchCancel.apply(self, arguments)
            };
            if (FastClick.notNeeded(layer)) {
                return
            }
            if (this.deviceIsAndroid) {
                layer.addEventListener("mouseover", this.onMouse, true);
                layer.addEventListener("mousedown", this.onMouse, true);
                layer.addEventListener("mouseup", this.onMouse, true)
            }
            layer.addEventListener("click", this.onClick, true);
            layer.addEventListener("touchstart", this.onTouchStart, false);
            layer.addEventListener("touchmove", this.onTouchMove, false);
            layer.addEventListener("touchend", this.onTouchEnd, false);
            layer.addEventListener("touchcancel", this.onTouchCancel, false);
            if (!Event.prototype.stopImmediatePropagation) {
                layer.removeEventListener = function(type, callback, capture) {
                    var rmv = Node.prototype.removeEventListener;
                    if (type === "click") {
                        rmv.call(layer, type, callback.hijacked || callback, capture)
                    } else {
                        rmv.call(layer, type, callback, capture)
                    }
                };
                layer.addEventListener = function(type, callback, capture) {
                    var adv = Node.prototype.addEventListener;
                    if (type === "click") {
                        adv.call(layer, type, callback.hijacked || (callback.hijacked = function(event) {
                                if (!event.propagationStopped) {
                                    callback(event)
                                }
                            }), capture)
                    } else {
                        adv.call(layer, type, callback, capture)
                    }
                }
            }
            if (typeof layer.onclick === "function") {
                oldOnClick = layer.onclick;
                layer.addEventListener("click", function(event) {
                    oldOnClick(event)
                }, false);
                layer.onclick = null
            }
        }
        FastClick.prototype.deviceIsAndroid = navigator.userAgent.indexOf("Android") > 0;
        FastClick.prototype.deviceIsIOS = /iP(ad|hone|od)/.test(navigator.userAgent);
        FastClick.prototype.deviceIsIOS4 = FastClick.prototype.deviceIsIOS && /OS 4_\d(_\d)?/.test(navigator.userAgent);
        FastClick.prototype.deviceIsIOSWithBadTarget = FastClick.prototype.deviceIsIOS && /OS ([6-9]|\d{2})_\d/.test(navigator.userAgent);
        FastClick.prototype.needsClick = function(target) {
            "use strict";
            switch (target.nodeName.toLowerCase()) {
                case "button":
                case "select":
                case "textarea":
                    if (target.disabled) {
                        return true
                    }
                    break;
                case "input":
                    if (this.deviceIsIOS && target.type === "file" || target.disabled) {
                        return true
                    }
                    break;
                case "label":
                case "video":
                    return true
            }
            return /\bneedsclick\b/.test(target.className)
        };
        FastClick.prototype.needsFocus = function(target) {
            "use strict";
            switch (target.nodeName.toLowerCase()) {
                case "textarea":
                    return true;
                case "select":
                    return !this.deviceIsAndroid;
                case "input":
                    switch (target.type) {
                        case "button":
                        case "checkbox":
                        case "file":
                        case "image":
                        case "radio":
                        case "submit":
                            return false
                    }
                    return !target.disabled && !target.readOnly;
                default:
                    return /\bneedsfocus\b/.test(target.className)
            }
        };
        FastClick.prototype.sendClick = function(targetElement, event) {
            "use strict";
            var clickEvent, touch;
            if (document.activeElement && document.activeElement !== targetElement) {
                document.activeElement.blur()
            }
            touch = event.changedTouches[0];
            clickEvent = document.createEvent("MouseEvents");
            clickEvent.initMouseEvent(this.determineEventType(targetElement), true, true, window, 1, touch.screenX, touch.screenY, touch.clientX, touch.clientY, false, false, false, false, 0, null);
            clickEvent.forwardedTouchEvent = true;
            targetElement.dispatchEvent(clickEvent)
        };
        FastClick.prototype.determineEventType = function(targetElement) {
            "use strict";
            if (this.deviceIsAndroid && targetElement.tagName.toLowerCase() === "select") {
                return "mousedown"
            }
            return "click"
        };
        FastClick.prototype.focus = function(targetElement) {
            "use strict";
            var length;
            if (this.deviceIsIOS && targetElement.setSelectionRange && targetElement.type.indexOf("date") !== 0 && targetElement.type !== "time") {
                length = targetElement.value.length;
                targetElement.setSelectionRange(length, length)
            } else {
                targetElement.focus()
            }
        };
        FastClick.prototype.updateScrollParent = function(targetElement) {
            "use strict";
            var scrollParent, parentElement;
            scrollParent = targetElement.fastClickScrollParent;
            if (!scrollParent || !scrollParent.contains(targetElement)) {
                parentElement = targetElement;
                do {
                    if (parentElement.scrollHeight > parentElement.offsetHeight) {
                        scrollParent = parentElement;
                        targetElement.fastClickScrollParent = parentElement;
                        break
                    }
                    parentElement = parentElement.parentElement
                } while (parentElement)
            }
            if (scrollParent) {
                scrollParent.fastClickLastScrollTop = scrollParent.scrollTop
            }
        };
        FastClick.prototype.getTargetElementFromEventTarget = function(eventTarget) {
            "use strict";
            if (eventTarget.nodeType === Node.TEXT_NODE) {
                return eventTarget.parentNode
            }
            return eventTarget
        };
        FastClick.prototype.onTouchStart = function(event) {
            "use strict";
            var targetElement, touch, selection;
            if (event.targetTouches.length > 1) {
                return true
            }
            targetElement = this.getTargetElementFromEventTarget(event.target);
            touch = event.targetTouches[0];
            if (this.deviceIsIOS) {
                selection = window.getSelection();
                if (selection.rangeCount && !selection.isCollapsed) {
                    return true
                }
                if (!this.deviceIsIOS4) {
                    if (touch.identifier === this.lastTouchIdentifier) {
                        event.preventDefault();
                        return false
                    }
                    this.lastTouchIdentifier = touch.identifier;
                    this.updateScrollParent(targetElement)
                }
            }
            this.trackingClick = true;
            this.trackingClickStart = event.timeStamp;
            this.targetElement = targetElement;
            this.touchStartX = touch.pageX;
            this.touchStartY = touch.pageY;
            if (event.timeStamp - this.lastClickTime < 200) {
                event.preventDefault()
            }
            return true
        };
        FastClick.prototype.touchHasMoved = function(event) {
            "use strict";
            var touch = event.changedTouches[0],
                boundary = this.touchBoundary;
            if (Math.abs(touch.pageX - this.touchStartX) > boundary || Math.abs(touch.pageY - this.touchStartY) > boundary) {
                return true
            }
            return false
        };
        FastClick.prototype.onTouchMove = function(event) {
            "use strict";
            if (!this.trackingClick) {
                return true
            }
            if (this.targetElement !== this.getTargetElementFromEventTarget(event.target) || this.touchHasMoved(event)) {
                this.trackingClick = false;
                this.targetElement = null
            }
            return true
        };
        FastClick.prototype.findControl = function(labelElement) {
            "use strict";
            if (labelElement.control !== undefined) {
                return labelElement.control
            }
            if (labelElement.htmlFor) {
                return document.getElementById(labelElement.htmlFor)
            }
            return labelElement.querySelector("button, input:not([type=hidden]), keygen, meter, output, progress, select, textarea")
        };
        FastClick.prototype.onTouchEnd = function(event) {
            "use strict";
            var forElement, trackingClickStart, targetTagName, scrollParent, touch, targetElement = this.targetElement;
            if (!this.trackingClick) {
                return true
            }
            if (event.timeStamp - this.lastClickTime < 200) {
                this.cancelNextClick = true;
                return true
            }
            this.cancelNextClick = false;
            this.lastClickTime = event.timeStamp;
            trackingClickStart = this.trackingClickStart;
            this.trackingClick = false;
            this.trackingClickStart = 0;
            if (this.deviceIsIOSWithBadTarget) {
                touch = event.changedTouches[0];
                targetElement = document.elementFromPoint(touch.pageX - window.pageXOffset, touch.pageY - window.pageYOffset) || targetElement;
                targetElement.fastClickScrollParent = this.targetElement.fastClickScrollParent
            }
            targetTagName = targetElement.tagName.toLowerCase();
            if (targetTagName === "label") {
                forElement = this.findControl(targetElement);
                if (forElement) {
                    this.focus(targetElement);
                    if (this.deviceIsAndroid) {
                        return false
                    }
                    targetElement = forElement
                }
            } else if (this.needsFocus(targetElement)) {
                if (event.timeStamp - trackingClickStart > 100 || this.deviceIsIOS && window.top !== window && targetTagName === "input") {
                    this.targetElement = null;
                    return false
                }
                this.focus(targetElement);
                if (!this.deviceIsIOS4 || targetTagName !== "select") {
                    this.targetElement = null;
                    event.preventDefault()
                }
                return false
            }
            if (this.deviceIsIOS && !this.deviceIsIOS4) {
                scrollParent = targetElement.fastClickScrollParent;
                if (scrollParent && scrollParent.fastClickLastScrollTop !== scrollParent.scrollTop) {
                    return true
                }
            }
            if (!this.needsClick(targetElement)) {
                event.preventDefault();
                this.sendClick(targetElement, event)
            }
            return false
        };
        FastClick.prototype.onTouchCancel = function() {
            "use strict";
            this.trackingClick = false;
            this.targetElement = null
        };
        FastClick.prototype.onMouse = function(event) {
            "use strict";
            if (!this.targetElement) {
                return true
            }
            if (event.forwardedTouchEvent) {
                return true
            }
            if (!event.cancelable) {
                return true
            }
            if (!this.needsClick(this.targetElement) || this.cancelNextClick) {
                if (event.stopImmediatePropagation) {
                    event.stopImmediatePropagation()
                } else {
                    event.propagationStopped = true
                }
                event.stopPropagation();
                event.preventDefault();
                return false
            }
            return true
        };
        FastClick.prototype.onClick = function(event) {
            "use strict";
            var permitted;
            if (this.trackingClick) {
                this.targetElement = null;
                this.trackingClick = false;
                return true
            }
            if (event.target.type === "submit" && event.detail === 0) {
                return true
            }
            permitted = this.onMouse(event);
            if (!permitted) {
                this.targetElement = null
            }
            return permitted
        };
        FastClick.prototype.destroy = function() {
            "use strict";
            var layer = this.layer;
            if (this.deviceIsAndroid) {
                layer.removeEventListener("mouseover", this.onMouse, true);
                layer.removeEventListener("mousedown", this.onMouse, true);
                layer.removeEventListener("mouseup", this.onMouse, true)
            }
            layer.removeEventListener("click", this.onClick, true);
            layer.removeEventListener("touchstart", this.onTouchStart, false);
            layer.removeEventListener("touchmove", this.onTouchMove, false);
            layer.removeEventListener("touchend", this.onTouchEnd, false);
            layer.removeEventListener("touchcancel", this.onTouchCancel, false)
        };
        FastClick.notNeeded = function(layer) {
            "use strict";
            var metaViewport;
            var chromeVersion;
            if (typeof window.ontouchstart === "undefined") {
                return true
            }
            chromeVersion = +(/Chrome\/([0-9]+)/.exec(navigator.userAgent) || [, 0])[1];
            if (chromeVersion) {
                if (FastClick.prototype.deviceIsAndroid) {
                    metaViewport = document.querySelector("meta[name=viewport]");
                    if (metaViewport) {
                        if (metaViewport.content.indexOf("user-scalable=no") !== -1) {
                            return true
                        }
                        if (chromeVersion > 31 && window.innerWidth <= window.screen.width) {
                            return true
                        }
                    }
                } else {
                    return true
                }
            }
            if (layer.style.msTouchAction === "none") {
                return true
            }
            return false
        };
        FastClick.attach = function(layer) {
            "use strict";
            return new FastClick(layer)
        };
        if (typeof define !== "undefined" && define.amd) {
            define(function() {
                "use strict";
                return FastClick
            })
        } else if (typeof module !== "undefined" && module.exports) {
            module.exports = FastClick.attach;
            module.exports.FastClick = FastClick
        } else {
            window.FastClick = FastClick
        }
    });
    require.register("switchery/switchery.js", function(exports, require, module) {
        var transitionize = require("transitionize"),
            fastclick = require("fastclick");
        module.exports = Switchery;
        var defaults = {
            color: "#64bd63",
            secondaryColor: "#dfdfdf",
            className: "switchery",
            disabled: false,
            disabledOpacity: .5,
            speed: "0.4s"
        };

        function Switchery(element, options) {
            if (!(this instanceof Switchery)) return new Switchery(element, options);
            this.element = element;
            this.options = options || {};
            for (var i in defaults) {
                if (this.options[i] == null) {
                    this.options[i] = defaults[i]
                }
            }
            if (this.element != null && this.element.type == "checkbox") this.init()
        }
        Switchery.prototype.hide = function() {
            this.element.style.display = "none"
        };
        Switchery.prototype.show = function() {
            var switcher = this.create();
            this.insertAfter(this.element, switcher)
        };
        Switchery.prototype.create = function() {
            this.switcher = document.createElement("span");
            this.jack = document.createElement("small");
            this.switcher.appendChild(this.jack);
            this.switcher.className = this.options.className;
            return this.switcher
        };
        Switchery.prototype.insertAfter = function(reference, target) {
            reference.parentNode.insertBefore(target, reference.nextSibling)
        };
        Switchery.prototype.isChecked = function() {
            return this.element.checked
        };
        Switchery.prototype.isDisabled = function() {
            return this.options.disabled || this.element.disabled
        };
        Switchery.prototype.setPosition = function(clicked) {
            var checked = this.isChecked(),
                switcher = this.switcher,
                jack = this.jack;
            if (clicked && checked) checked = false;
            else if (clicked && !checked) checked = true;
            if (checked === true) {
                this.element.checked = true;
                if (window.getComputedStyle) jack.style.left = parseInt(window.getComputedStyle(switcher).width) - parseInt(window.getComputedStyle(jack).width) + "px";
                else jack.style.left = parseInt(switcher.currentStyle["width"]) - parseInt(jack.currentStyle["width"]) + "px";
                if (this.options.color) this.colorize();
                this.setSpeed()
            } else {
                jack.style.left = 0;
                this.element.checked = false;
                this.switcher.style.boxShadow = "inset 0 0 0 0 " + this.options.secondaryColor;
                this.switcher.style.borderColor = this.options.secondaryColor;
                this.switcher.style.backgroundColor = "";
                this.setSpeed()
            }
        };
        Switchery.prototype.setSpeed = function() {
            var switcherProp = {},
                jackProp = {
                    left: this.options.speed.replace(/[a-z]/, "") / 2 + "s"
                };
            if (this.isChecked()) {
                switcherProp = {
                    border: this.options.speed,
                    "box-shadow": this.options.speed,
                    "background-color": this.options.speed.replace(/[a-z]/, "") * 3 + "s"
                }
            } else {
                switcherProp = {
                    border: this.options.speed,
                    "box-shadow": this.options.speed
                }
            }
            transitionize(this.switcher, switcherProp);
            transitionize(this.jack, jackProp)
        };
        Switchery.prototype.setAttributes = function() {
            var id = this.element.getAttribute("id");
            if (id) this.switcher.setAttribute("id", id);

        };
        Switchery.prototype.colorize = function() {
            this.switcher.style.backgroundColor = this.options.color;
            this.switcher.style.borderColor = this.options.color;
            this.switcher.style.boxShadow = "inset 0 0 0 16px " + this.options.color
        };
        Switchery.prototype.handleOnchange = function(state) {
            if (typeof Event === "function" || !document.fireEvent) {
                var event = document.createEvent("HTMLEvents");
                event.initEvent("change", true, true);
                this.element.dispatchEvent(event)
            } else {
                this.element.fireEvent("onchange")
            }
        };
        Switchery.prototype.handleChange = function() {
            var self = this,
                el = this.element;
            if (el.addEventListener) {
                el.addEventListener("change", function() {
                    self.setPosition()
                })
            } else {
                el.attachEvent("onchange", function() {
                    self.setPosition()
                })
            }
        };
        Switchery.prototype.handleClick = function() {
            var self = this,
                switcher = this.switcher;
            if (this.isDisabled() === false) {
                fastclick(switcher);
                if (switcher.addEventListener) {
                    switcher.addEventListener("click", function() {
                        self.setPosition(true);
                        self.handleOnchange(self.element.checked)
                    })
                } else {
                    switcher.attachEvent("onclick", function() {
                        self.setPosition(true);
                        self.handleOnchange(self.element.checked)
                    })
                }
            } else {
                this.element.disabled = true;
                this.switcher.style.opacity = this.options.disabledOpacity
            }
        };
        Switchery.prototype.disableLabel = function() {
            var parent = this.element.parentNode,
                labels = document.getElementsByTagName("label"),
                attached = null;
            for (var i = 0; i < labels.length; i++) {
                if (labels[i].getAttribute("for") === this.element.id) {
                    attached = true
                }
            }
            if (attached === true || parent.tagName.toLowerCase() === "label") {
                if (parent.addEventListener) {
                    parent.addEventListener("click", function(e) {
                        e.preventDefault()
                    })
                } else {
                    parent.attachEvent("onclick", function(e) {
                        e.returnValue = false
                    })
                }
            }
        };
        Switchery.prototype.markAsSwitched = function() {
            this.element.setAttribute("data-switchery", true)
        };
        Switchery.prototype.markedAsSwitched = function() {
            return this.element.getAttribute("data-switchery")
        };
        Switchery.prototype.init = function() {
            this.hide();
            this.show();
            this.setPosition();
            this.setAttributes();
            this.markAsSwitched();
            this.disableLabel();
            this.handleChange();
            this.handleClick()
        }
    });
    require.alias("abpetkov-transitionize/transitionize.js", "switchery/deps/transitionize/transitionize.js");
    require.alias("abpetkov-transitionize/transitionize.js", "switchery/deps/transitionize/index.js");
    require.alias("abpetkov-transitionize/transitionize.js", "transitionize/index.js");
    require.alias("abpetkov-transitionize/transitionize.js", "abpetkov-transitionize/index.js");
    require.alias("ftlabs-fastclick/lib/fastclick.js", "switchery/deps/fastclick/lib/fastclick.js");
    require.alias("ftlabs-fastclick/lib/fastclick.js", "switchery/deps/fastclick/index.js");
    require.alias("ftlabs-fastclick/lib/fastclick.js", "fastclick/index.js");
    require.alias("ftlabs-fastclick/lib/fastclick.js", "ftlabs-fastclick/index.js");
    require.alias("switchery/switchery.js", "switchery/index.js");
    if (typeof exports == "object") {
        module.exports = require("switchery")
    } else if (typeof define == "function" && define.amd) {
        define(function() {
            return require("switchery")
        })
    } else {
        this["Switchery"] = require("switchery")
    }
})();